home *** CD-ROM | disk | FTP | other *** search
/ Scene Storm / Scene Storm - Volume 1.iso / coding / asm / games / texturemapping / 3d.asm next >
Assembly Source File  |  1980-01-03  |  12KB  |  649 lines
  1. ; $$TABS=8
  2.     include    'demo.i'
  3. ; simple 3d package
  4. ; only supports heading for now.
  5.  
  6.     xref    PlayerHeading,PlayerX,PlayerY,PlayerZ
  7.     xref    current_color,sincos,UnClippedPolygon,vertex
  8.     xref    DrawClippedPolygon
  9.     xref    YLRCCFill,YLRUUFill,YLRFiller,lightingtab,current_ltab
  10.     
  11.     xref    KingTut,Fish,Mandrill,Wolves,current_tmap
  12.  
  13. DUNGEON_PT_SIZE    equ    16    ; xyzcuv..
  14. DUNGEON_PT_SHIFT    equ    4
  15.  
  16. render_3d::
  17.     ONTIMER    3
  18.     bsr    generate_matrix
  19.     clr.l    current_color(a6)
  20.     bsr    DoGridPoints
  21.     ONTIMER    12
  22.     bsr    LightPoints
  23.     OFFTIMER    12
  24.     move.l    #YLRCCFill,YLRFiller(a6)
  25.     bsr    RenderFloor
  26.     move.l    #YLRUUFill,YLRFiller(a6)
  27.     bsr    add_objects
  28.     OFFTIMER    3
  29.     rts
  30.  
  31.  
  32. generate_matrix::
  33.     move.w    PlayerHeading(a6),d0
  34.     neg.w    d0
  35.     bsr    sincos        ; d0=sin d1=cos
  36.     move.w    d1,m11(a6)
  37.     move.w    d1,m33(a6)
  38.     move.w    d0,m31(a6)
  39.     neg.w    d0
  40.     move.w    d0,m13(a6)
  41.     asr.w    m13(a6)
  42.     asr.w    m33(a6)
  43.     rts
  44.  
  45. XForm32::
  46. ; entr d4/d5/d6=xyz
  47. ; returns d4-d6=32 bit xyz
  48. ; trashes d0/d7
  49.     sub.l    PlayerX(a6),d4
  50.     sub.l    PlayerY(a6),d5
  51.     sub.l    PlayerZ(a6),d6
  52.     muls    m22(a6),d5
  53.     add.l    d5,d5
  54.     move.l    d4,d0
  55.     move.l    d6,d7    
  56.     muls    m11(a6),d4
  57.     muls    m31(a6),d7
  58.     add.l    d7,d4
  59.     add.l    d4,d4
  60.     muls    m13(a6),d0
  61.     muls    m33(a6),d6
  62.     add.l    d0,d6
  63.     add.l    d6,d6
  64.     rts
  65.  
  66.  
  67. Do3dPoint:
  68. ; entr (a5)=16 bit xyz coordinates
  69. ; exit:d4-d7=point,codes
  70. ;      (a5)=next point
  71. ; trashes: d0
  72. ;
  73.     movem.w    (a5),d4/d5/d6
  74.     lea    3*2(a5),a5
  75.     sub.l    PlayerX(a6),d4
  76.     sub.l    PlayerY(a6),d5
  77.     sub.l    PlayerZ(a6),d6
  78.  
  79. matrix_multiply::
  80. ; for a pure heading matrix, only m11, m13, m31, m33 are important
  81. ; (to throw in y scaling, m22 is the key)
  82. ; x'=(xyz).(m11,m21,m31)
  83. ; y'=(xyz).(m12,m22,m32)
  84. ; z'=(xyz).(m13,m23,m33)
  85. ; entr: d4-d6=xyz
  86. ; exit: d4-d6.w=xyz' d7=codes
  87. ; trashes:
  88.     muls    m22(a6),d5
  89.     add.l    d5,d5
  90.     swap    d5
  91.     move.l    d4,d0
  92.     move.l    d6,d7    
  93.     muls    m11(a6),d4
  94.     muls    m31(a6),d7
  95.     add.l    d7,d4
  96.     add.l    d4,d4
  97.     swap    d4
  98.     muls    m13(a6),d0
  99.     muls    m33(a6),d6
  100.     add.l    d0,d6
  101.     add.l    d6,d6
  102.     swap    d6
  103.  
  104. point_coder::
  105. ; d7=codes(d4,d5,d6)
  106. ; B0 = point to left of z=-x
  107. ; B1 = point to right of z=x
  108. ; B2 = point above z=y
  109. ; B3 = point below z=-y
  110. ; B8 = z<0 (2d clip-possible flag)
  111. ; cc reflects d7
  112.     move    d6,d7
  113.     neg    d7
  114.     bge.s    set_7
  115.     cmp    d7,d4
  116.     blt.s    set_0
  117.     cmp    d6,d4
  118.     bgt.s    set_1
  119.     cmp    d6,d5
  120.     bgt.s    set_2
  121.     cmp    d7,d5
  122.     blt.s    set_3
  123.     moveq    #0,d7
  124.     rts
  125. set_0:    cmp    d6,d5
  126.     bgt.s    set_902
  127.     cmp    d7,d5
  128.     blt.s    set_903
  129.     moveq    #1,d7
  130.     rts
  131. set_902:
  132.     moveq    #5,d7
  133.     rts
  134. set_903:
  135.     moveq    #9,d7
  136.     rts
  137. set_1:    cmp    d6,d5
  138.     bgt.s    set_12
  139.     cmp    d7,d5
  140.     blt.s    set_13
  141.     moveq    #2,d7
  142.     rts
  143. set_12:    moveq    #6,d7
  144.     rts
  145. set_13:    moveq    #$0a,d7
  146.     rts
  147. set_2:    moveq    #4,d7
  148.     rts
  149. set_3:    moveq    #8,d7
  150.     rts
  151. set_7:    cmp    d7,d4
  152.     blt.s    set_8
  153.     cmp    d6,d5
  154.     bgt.s    set_712
  155.     moveq    #$ffffff8a,d7
  156.     rts
  157. set_8:    cmp    d6,d4
  158.     bgt.s    set_81
  159.     cmp    d6,d5
  160.     bgt.s    set_82
  161.     moveq    #$ffffff89,d7
  162.     rts
  163. set_81:    cmp    d6,d5
  164.     bgt.s    set_52
  165.     moveq    #$ffffff8b,d7
  166.     rts
  167. set_52:    cmp    d7,d5
  168.     blt.s    set_523
  169.     moveq    #$ffffff87,d7
  170.     rts
  171. set_523:
  172.     moveq    #$ffffff8f,d7
  173.     rts
  174. set_82:    cmp    d7,d5
  175.     blt.s    set_823
  176.     moveq    #$ffffff85,d7
  177.     rts
  178. set_823:
  179.     moveq    #$ffffff8d,d7
  180. q    rts
  181. set_712:
  182.     cmp    d7,d5
  183.     blt.s    set_4
  184.     moveq    #$ffffff86,d7
  185.     rts
  186. set_4:    moveq    #$ffffff8e,d7
  187.     rts
  188.  
  189. DUNGEON_MINX    equ    -8192
  190. DUNGEON_MINZ    equ    -8192
  191. DUNGEON_XSTEP    equ    16384*2/(DUNGEON_GRID_SIZE)
  192. DUNGEON_ZSTEP    equ    16384*2/(DUNGEON_GRID_SIZE)
  193. DUNGEON_Y        equ    0
  194. DUNGEON_TOPY    equ    2000
  195.  
  196. LightPoints:
  197. ; now, light all grid points.
  198. ; intens=intenstable(|x^2+z^2|)
  199.     move.l    #DUNGEON_MINX,d0
  200.     move.l    #DUNGEON_MINZ,d1
  201.     sub.l    PlayerX(a6),d0
  202.     sub.l    PlayerZ(a6),d1
  203.     move.w    #DUNGEON_GRID_SIZE-1,d2    ; outer counter
  204.     move.l    #DungeonPoints,a0
  205.     move.l    #intenstable,a2
  206. outer_lloop:
  207.     move.l    a0,a1            ; save
  208.     move.l    d0,d7
  209.     move.w    #(DUNGEON_GRID_SIZE)-1,d3    ; inner counter
  210.     move    d1,d5
  211.     muls    d5,d5
  212. inner_lloop:
  213.     move    d0,d4
  214.     muls.w    d4,d4
  215.     add.l    d5,d4
  216.     bpl.s    1$
  217.     neg.l    d4
  218. 1$:
  219.     swap    d4
  220.     cmp.w    #256,d4
  221.     blo.s    2$
  222.     move.w    #255,d4
  223. 2$:    move.w    (a2,d4.w*2),d4
  224.     move.w    d4,8(a0)
  225.  
  226.     ifne    DO_CEILING
  227.     move.w    d4,d6
  228.     mulu    10+DUNGEON_PT_SIZE(a0),d6
  229.     swap    d6
  230.     move    d6,10+DUNGEON_PT_SIZE(a0)
  231.     endc
  232.  
  233.     mulu    10(a0),d4
  234.     swap    d4
  235.     move.w    d4,10(a0)
  236.  
  237.  
  238.     add.l    #DUNGEON_XSTEP/2,d0
  239.     lea    DUNGEON_PT_SIZE*2(a0),a0
  240.     dbra    d3,inner_lloop
  241.     lea    DUNGEON_GRID_SIZE*2*DUNGEON_PT_SIZE(a1),a0
  242.     move.l    d7,d0
  243.     add.l    #DUNGEON_ZSTEP/2,d1
  244.     dbra    d2,outer_lloop
  245.     rts
  246.  
  247. DoGridPoints:
  248. ; fill DungeonPoints with interpolated grid
  249. ; 
  250. ; startpt=xform32(MINX,0,MINZ)
  251. ; dp/dx=(m11*xstep,0,m13*xstep)
  252. ; dp/dz=(m31*zstep,0,m33*zstep)
  253. ; for(i=0;i<grid_size;i++)
  254. ;   tempp=startpt
  255. ;   for(j=0;j<grid_size;j++)
  256. ;     *(nextpt++)=tempp *(nextpt++)=codes(tempp)
  257. ;     tempp+-dp/dx
  258. ;   startpt+=dp/dz
  259.  
  260.     move.w    #$1234,rand_seed(a6)
  261.     ONTIMER    8
  262.     move.l    #DUNGEON_MINX,d4
  263.     move.l    #DUNGEON_Y,d5
  264.     move.l    #DUNGEON_MINZ,d6
  265.     bsr    XForm32                ; d4-d6=upper left corner
  266.     swap    d5
  267. ; now, gen deltas
  268.     move.l    #DUNGEON_TOPY,d0
  269.     sub.l    PlayerY(a6),d0
  270.     muls    m22(a6),d0
  271.     add.l    d0,d0
  272.     swap    d0
  273.     move.w    m11(a6),d1
  274.     muls    #DUNGEON_XSTEP,d1
  275.     move.l    d1,a5
  276.     move.w    m13(a6),d1
  277.     muls    #DUNGEON_XSTEP,d1        ; a5/d1=dp/dx
  278.     move.w    m31(a6),d2
  279.     muls    #DUNGEON_ZSTEP,d2
  280.     move.w    m33(a6),d3
  281.     muls    #DUNGEON_ZSTEP,d3
  282.     move.l    d2,a1
  283.     move.l    d3,a2                ; a1/a2=dp/dz
  284.     move.l    #DungeonPoints,a0
  285.     moveq    #DUNGEON_GRID_SIZE-1,d2        ; outer counter
  286. outer_loop:
  287.     move.l    d4,a3                ; save
  288.     move.l    d6,a4
  289.     moveq    #DUNGEON_GRID_SIZE-1,d3        ; inner counter
  290. inner_loop:
  291.     swap    d4
  292.     swap    d6
  293.     bsr    point_coder
  294.     movem.w    d4-d7,(a0)
  295.     move.w    rand_seed(a6),d7
  296.     mulu    #$1efd,d7
  297.     add    #$dff,d7
  298.     move.w    d7,rand_seed(a6)
  299.     move.w    d7,10(a0)
  300.     exg.l    d0,d5
  301.     bsr    point_coder
  302.     movem.w    d4-d7,DUNGEON_PT_SIZE(a0)
  303.  
  304.     ifne    DO_CEILING
  305.     move.w    rand_seed(a6),d7
  306.     mulu    #$1efd,d7
  307.     add    #$dff,d7
  308.     move.w    d7,rand_seed(a6)
  309.     move.w    d7,DUNGEON_PT_SIZE+10(a0)
  310.     endc
  311.  
  312.     lea    DUNGEON_PT_SIZE*2(a0),a0
  313.     exg.l    d0,d5
  314.     swap    d4
  315.     swap    d6
  316.     add.l    a5,d4
  317.     add.l    d1,d6
  318.     dbra    d3,inner_loop
  319.     move.l    a3,d4
  320.     move.l    a4,d6
  321.     add.l    a1,d4
  322.     add.l    a2,d6
  323.     dbra    d2,outer_loop
  324.     OFFTIMER    8
  325.     rts
  326.  
  327. RenderFloor:
  328. ; now, let's attempt to fill polygons for a test
  329. ; for(i=0;i<npoints-1;i++)
  330. ;  for(j=0;j<npoints-1;j++)
  331. ;   dopoly(dp[i,j],dp[i,j+1],dp[i+1,j+1],dp[i+1,j]
  332.     ONTIMER    9
  333.     move.l    #DungeonPoints,a0
  334.     move.w    #DUNGEON_GRID_SIZE-2,d7    ; outer
  335. 1$:
  336.     ifne    DO_CEILING
  337.     move.w    #((DUNGEON_GRID_SIZE-1)*2)-1,d6    ; inner
  338.     else
  339.     move.w    #(DUNGEON_GRID_SIZE-1)-1,d6
  340.     endc
  341.  
  342.     move.l    a0,a1            ; save
  343. 2$:
  344.     lea    temp_polygon_buffer(a6),a2
  345.     movem.w    (a1),d2/d3/d4/d5        ; xyzc
  346.     move.w    d5,d0        ; orcodes
  347.     move.w    d5,d1        ; andcodes
  348.     movem.w    d2/d3/d4/d5,(a2)
  349.     move.w    10(a1),8(a2)
  350.     lea    6*2(a2),a2
  351.  
  352.     movem.w    DUNGEON_PT_SIZE*2(a1),d2/d3/d4/d5        ; xyzc
  353.     or.w    d5,d0
  354.     and.w    d5,d1
  355.     movem.w    d2/d3/d4/d5,(a2)
  356.     move.w    DUNGEON_PT_SIZE*2+10(a1),8(a2)
  357.     lea    6*2(a2),a2
  358.  
  359.     movem.w    DUNGEON_GRID_SIZE*DUNGEON_PT_SIZE*2+DUNGEON_PT_SIZE*2(a1),d2/d3/d4/d5
  360.                     ; xyzc
  361.     or.w    d5,d0
  362.     and.w    d5,d1
  363.     movem.w    d2/d3/d4/d5,(a2)
  364.     move.w    DUNGEON_GRID_SIZE*DUNGEON_PT_SIZE*2+DUNGEON_PT_SIZE*2+10(a1),8(a2)
  365.     lea    6*2(a2),a2
  366.  
  367.     movem.w    DUNGEON_GRID_SIZE*DUNGEON_PT_SIZE*2(a1),d2/d3/d4/d5        ; xyzc
  368.     and.w    d5,d1
  369.     bne.s    3$    ; trivial reject
  370.     or.w    d5,d0
  371.     movem.w    d2/d3/d4/d5,(a2)
  372.     move.w    DUNGEON_GRID_SIZE*DUNGEON_PT_SIZE*2+10(a1),8(a2)
  373.     lea    6*2(a2),a2
  374.     movem.l    d6/d7/a0/a1,-(a7)
  375.     move.l    a2,a1
  376.     lea    temp_polygon_buffer(a6),a0
  377.     OFFTIMER    9
  378.     bsr    DrawClippedPolygon
  379.     ONTIMER    9
  380.     movem.l    (a7)+,d6/d7/a0/a1
  381. 3$:    ifne    DO_CEILING
  382.     lea    DUNGEON_PT_SIZE(a1),a1    ; was *2
  383.     else
  384.     lea    DUNGEON_PT_SIZE*2(a1),a1
  385.     endc
  386.     dbra    d6,2$
  387.     lea    DUNGEON_GRID_SIZE*DUNGEON_PT_SIZE*2(a0),a0
  388.     dbra    d7,1$
  389.     OFFTIMER    9
  390. done_3dblock:
  391.     rts
  392.  
  393. DO_FACE    macro    x1,z1,x2,z2
  394. ;        \1 \2 \3 \4
  395. ; generate x1,-y,z1 x2,-y,z2 x2,+y,z2 x1,+y,z1
  396.     moveq    #0,d0    ;; codes_or
  397.     moveq    #-1,d1    ;; codes_and
  398.     lea    temp_polygon_buffer(a6),a1
  399.     move.l    a1,a0
  400.     move.l    \2,d3
  401.     lsl.l    #DUNGEON_GRID_SHIFT,d3
  402.     add.l    \1,d3
  403.     lsl.l    #DUNGEON_PT_SHIFT+1,d3
  404.     move.l    #DungeonPoints,a2
  405.     add.l    d3,a2
  406.     move.w    6(a2),d3
  407.     or.w    d3,d0
  408.     and.w    d3,d1
  409.     move.l    (a2),(a1)
  410.     move.l    4(a2),4(a1)
  411.     move.l    #$7fff0000,8(a1)
  412.     move.w    8(a2),d2
  413.     move.w    DUNGEON_PT_SIZE+6(a2),d3
  414.     or.w    d3,d0
  415.     and.w    d3,d1
  416.     move.l    DUNGEON_PT_SIZE(a2),36(a1)
  417.     move.l    DUNGEON_PT_SIZE+4(a2),40(a1)
  418.     move.l    #$00000000,44(a1)
  419.     move.l    \4,d3
  420.     lsl.l    #DUNGEON_GRID_SHIFT,d3
  421.     add.l    \3,d3
  422.     lsl.l    #DUNGEON_PT_SHIFT+1,d3
  423.     move.l    #DungeonPoints,a2
  424.     add.l    d3,a2
  425.     move.w    6(a2),d3
  426.     or.w    d3,d0
  427.     and.w    d3,d1
  428.     move.l    (a2),12(a1)
  429.     move.l    4(a2),16(a1)
  430.     add.w    8(a2),d2
  431.     move.l    #$7fff7fff,20(a1)
  432.     move.w    DUNGEON_PT_SIZE+6(a2),d3
  433.     or.w    d3,d0
  434.     and.w    d3,d1
  435.     bne.s    trivial_reject\@
  436.     move.l    DUNGEON_PT_SIZE(a2),24(a1)
  437.     move.l    DUNGEON_PT_SIZE+4(a2),28(a1)
  438.     move.l    #$00007fff,32(a1)
  439. ; now, d2=ltab
  440.     sub.l    a2,a2
  441.     lsr.w    #1,d2
  442.     beq.s    trivial_reject\@
  443.     cmp.w    #$2f00,d2
  444.     bhs.s    got_ltab\@
  445.     clr.b    d2
  446.     move.l    #lightingtab,a2
  447.     add.w    d2,a2
  448. got_ltab\@:
  449.     move.l    a2,current_ltab(a6)
  450.     lea    12*4(a1),a1
  451.     movem.l    d4-d7,-(a7)
  452.     bsr    DrawClippedPolygon
  453.     movem.l    (a7)+,d4-d7
  454. trivial_reject\@:
  455.     endm
  456.  
  457.  
  458.  
  459. do_3dblock::
  460. ; passed (a3)=&block
  461. ; adr(x,z)=((z*gridsize)+x)*16
  462. ; first, do upper face
  463.     movem.w    (a3),d4/d5/d6/d7    ; minx,minx,maxx,maxz
  464. ; now, check if can see upper face
  465. ; if 1024*(b.maxz)+DUNGEON_MINZ <PlayerZ, then visible
  466.     move.l    d7,d0
  467.     lsl.l    #8,d0
  468.     lsl.l    #2,d0
  469.     add.l    #DUNGEON_MINZ,d0
  470.     cmp.l    PlayerZ(a6),d0
  471.     bge    no_topface
  472. ; for clockwise face, do minx,+y,maxz minx,-y,maxz maxx,-y,maxz maxx,+y,maxz
  473.     move.l    #KingTut,current_tmap(a6)
  474.     DO_FACE    d4,d7,d6,d7
  475. no_topface:
  476. ; now, do left face
  477. ; if playerx < (1024*(b.minx)) then visible
  478.     move.l    d4,d0
  479.     lsl.l    #8,d0
  480.     lsl.l    #2,d0
  481.     add.l    #DUNGEON_MINX,d0
  482.     cmp.l    PlayerX(a6),d0
  483.     ble    no_leftface
  484.     move.l    #Fish,current_tmap(a6)
  485.     DO_FACE    d4,d5,d4,d7
  486. no_leftface:
  487. ; now, do right face
  488. ; if playerx > (1024*max+minx) then visible
  489.     move.l    d6,d0
  490.     lsl.l    #8,d0
  491.     lsl.l    #2,d0
  492.     add.l    #DUNGEON_MINX,d0
  493.     cmp.l    PlayerX(a6),d0
  494.     bge    no_rightface
  495.     move.l    #Wolves,current_tmap(a6)
  496.     DO_FACE    d6,d7,d6,d5
  497.  
  498. no_rightface:
  499. ; now, do lower face
  500. ; if playerZ < minz then visible
  501.     move.l    d5,d0
  502.     lsl.l    #8,d0
  503.     lsl.l    #2,d0
  504.     add.l    #DUNGEON_MINZ,d0
  505.     cmp.l    PlayerZ(a6),d0
  506.     ble    no_botface
  507.     move.l    #Mandrill,current_tmap(a6)
  508.     DO_FACE    d6,d5,d4,d5
  509. no_botface:
  510.     rts
  511.  
  512.  
  513. add_objects::
  514. ; lame "distance" sort
  515.     lea    ObjectList,a0
  516.     move.l    PlayerX(a6),d2
  517.     move.l    PlayerZ(a6),d3
  518.     lea    sortlist(a6),a1
  519. next_object::
  520.     tst.l    (a0)+        ; terminator?
  521.     beq.s    done_adding
  522. do_add:    move.l    (a0)+,d0    ; x
  523.     move.l    (a0)+,d1    ; z
  524.     sub.l    d2,d0
  525.     bpl.s    1$
  526.     neg.l    d0
  527. 1$:    sub.l    d3,d1
  528.     bpl.s    2$
  529.     neg.l    d1
  530. 2$:    cmp.l    d0,d1
  531.     bhs.s    3$
  532.     exg.l    d0,d1
  533. 3$:    add.l    d1,d1
  534.     add.l    d1,d0        ; d0=distance approximation
  535.     cmp.l    4(a0),d0
  536.     bhs.s    no_add_to_sorted_list
  537.     move.l    d0,(a0)        ; save distance
  538.     move.l    a0,(a1)+
  539. no_add_to_sorted_list:
  540.     lea    12(a0),a0    ; skip to next object
  541.     tst.l    (a0)+
  542.     bne.s    do_add
  543. done_adding:
  544. ; now, sort list from a0 to a1
  545. ; only a tiny number of objects, so use bubble sort
  546.     lea    -4(a1),a2
  547. outer:    lea    sortlist(a6),a0
  548.     cmp.l    a0,a2
  549.     ble.s    done_outer
  550. resort:    cmp.l    a0,a2
  551.     beq.s    done_inner
  552.     move.l    (a0)+,a3
  553.     move.l    (a0),a4
  554.     move.l    (a3),d0
  555.     cmp.l    (a4),d0
  556.     bhs.s    resort
  557.     move.l    a4,-4(a0)
  558.     move.l    a3,(a0)
  559.     bra.s    resort
  560. done_inner:
  561.     lea    -4(a2),a2
  562.     bra.s    outer
  563. done_outer:
  564.  
  565. ; now, drain sort list
  566.     lea    sortlist(a6),a0
  567. nextobject:
  568.     cmp.l    a0,a1        ; at end?
  569.     beq.s    done_plotting_objects
  570.     move.l    (a0)+,a3
  571.     move.l    -12(a3),a4    ; get handler pointer
  572.     move.l    8(a3),a3    ; get data pointer
  573.     movem.l    a0/a1,-(a7)
  574.     jsr    (a4)
  575.     movem.l    (a7)+,a0/a1
  576.     bra.s    nextobject
  577. done_plotting_objects:
  578.     rts
  579.  
  580.     section    __MERGED,data
  581. m11::    dc.w    $7fff
  582. m21::    dc.w    0
  583. m31::    dc.w    0
  584. m12::    dc.w    0
  585. m22::    dc.w    -$73ff
  586. m32::    dc.w    0
  587. m13::    dc.w    0
  588. m23::    dc.w    0
  589. m33::    dc.w    $7fff
  590.  
  591. rand_seed::    dc.w    1
  592.  
  593. sortlist::
  594.     ds.l    20
  595.  
  596. tmap_selector::
  597.     dc.w    0
  598.  
  599. temp_polygon_buffer::
  600.     ds.w    6*18
  601.  
  602.     section    DungeonArray,DATA
  603. defblock    macro    x,z,sym
  604. ;        \1\2 \3
  605.     dc.l    do_3dblock
  606.     dc.l    -8192+512+(\1*1024)
  607.     dc.l    -8192+512+(\2*1024)
  608.     dc.l    0
  609.     dc.l    8192+4096
  610.     dc.l    \3
  611.     endm
  612.  
  613. ; dc.w x,y,z,codes,x,y,z,codes [0,0]
  614. ; dc.w x,y,z,codes,x,y,z,codes [1,0]
  615. DungeonPoints::
  616.     ds.w    DUNGEON_GRID_SIZE*DUNGEON_GRID_SIZE*DUNGEON_PT_SIZE
  617.  
  618. ObjectList::
  619.  
  620.     defblock    1,1,block_b1
  621.     defblock    2,2,block_b2
  622.     defblock    1,3,block_b3
  623.     defblock    12,1,block_b4
  624.     defblock    7,4,block_b5
  625.     defblock    4,5,block_b6
  626.     defblock    12,7,block_b7
  627.     defblock    2,10,block_b8
  628.     defblock    2,13,block_b9
  629.     defblock    6,11,block_b10
  630.     defblock    11,13,block_b11
  631.     dc.l    0            ; terminator
  632.  
  633. block_b1:    dc.w    1,1,1+1,1+1
  634. block_b2:    dc.w    2,2,2+1,2+1
  635. block_b3:    dc.w    1,3,1+1,3+1
  636. block_b4:    dc.w    12,1,12+1,1+1
  637. block_b5:    dc.w    7,4,7+1,4+1
  638. block_b6:    dc.w    4,5,4+1,5+1
  639. block_b7:    dc.w    12,7,12+1,7+1
  640. block_b8:    dc.w    2,10,2+1,10+1
  641. block_b9:    dc.w    2,13,2+1,13+1
  642. block_b10:    dc.w    6,11,6+1,11+1
  643. block_b11:    dc.w    11,13,11+1,13+1
  644.  
  645.  
  646.     section    IntensityTable,DATA
  647. intenstable::
  648.     include    'intens.i'
  649.